home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Text / WASTE / WASTE 1.1.2 Distribution / Pseudo-UPI for THINK Pascal / Memory.p < prev    next >
Encoding:
Text File  |  1995-10-12  |  10.2 KB  |  429 lines  |  [TEXT/PJMM]
  1. unit Memory;
  2.  
  3. { Pascal Interface to the Macintosh Libraries }
  4.  
  5. { Copyright © Apple Computer Inc. }
  6. { All Rights Reserved }
  7.  
  8. { Adapted for use with THINK Pascal 4.0.x by Marco Piovanelli }
  9.  
  10. interface
  11.     uses
  12.         Types;
  13.  
  14.     const
  15.         maxSize = $800000;                        {Max data block size is 8 megabytes}
  16.         defaultPhysicalEntryCount = 8;
  17. { values returned from the GetPageState function }
  18.         kPageInMemory = 0;
  19.         kPageOnDisk = 1;
  20.         kNotPaged = 2;
  21.  
  22. { masks for Zone->heapType field }
  23.         k32BitHeap = 1;                            { valid in all Memory Managers }
  24.         kNewStyleHeap = 2;                            { true if new Heap Manager is present }
  25.         kNewDebugHeap = 4;                            { true if new Heap Manager is running in debug mode on this heap }
  26.  
  27. { size of a block in bytes }
  28.  
  29.     type
  30.         Size = LONGINT;
  31.  
  32.         GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  33.         PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  34.     {}
  35. {        UserFnProcPtr uses register based parameters on the 68k and cannot}
  36. {        be written in or called from a high-level language without the help of}
  37. {        mixed mode or assembly glue.}
  38. {}
  39. {        In:}
  40. {         => *parameter      A0.L}
  41. {    }
  42.         UserFnProcPtr = ProcPtr;  { PROCEDURE UserFn(parameter: UNIV Ptr); }
  43.         GrowZoneUPP = UniversalProcPtr;
  44.         PurgeUPP = UniversalProcPtr;
  45.         UserFnUPP = UniversalProcPtr;
  46.  
  47.         THz = ^Zone;
  48.  
  49.         Zone = record
  50.                 bkLim: Ptr;
  51.                 purgePtr: Ptr;
  52.                 hFstFree: Ptr;
  53.                 zcbFree: LONGINT;
  54.                 gzProc: GrowZoneUPP;
  55.                 moreMast: INTEGER;
  56.                 flags: INTEGER;
  57.                 cntRel: INTEGER;
  58.                 maxRel: INTEGER;
  59.                 cntNRel: INTEGER;
  60.                 heapType: SInt8;
  61.                 unused: SInt8;
  62.                 cntEmpty: INTEGER;
  63.                 cntHandles: INTEGER;
  64.                 minCBFree: LONGINT;
  65.                 purgeProc: PurgeUPP;
  66.                 sparePtr: Ptr;
  67.                 allocPtr: Ptr;
  68.                 heapData: INTEGER;
  69.             end;
  70.         MemoryBlock = record
  71.                 address: Ptr;
  72.                 count: LONGINT;
  73.             end;
  74.         LogicalToPhysicalTable = record
  75.                 logical: MemoryBlock;
  76.                 physical: array[0..7] of MemoryBlock;
  77.             end;
  78.         PageState = INTEGER;
  79.  
  80.         StatusRegisterContents = INTEGER;
  81.  
  82.     const
  83.         uppGrowZoneProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  84.         uppPurgeProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  85.         uppUserFnProcInfo = $00009802; { Register PROCEDURE (4 bytes in A0); }
  86.  
  87.     function NewGrowZoneProc (userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  88.     inline
  89.         $2E9F;
  90.  
  91.     function NewPurgeProc (userRoutine: PurgeProcPtr): PurgeUPP;
  92.     inline
  93.         $2E9F;
  94.  
  95.     function NewUserFnProc (userRoutine: UserFnProcPtr): UserFnUPP;
  96.     inline
  97.         $2E9F;
  98.  
  99.     function CallGrowZoneProc (cbNeeded: Size;
  100.                                     userRoutine: GrowZoneUPP): LONGINT;
  101.     inline
  102.         $205F, $4E90;
  103.  
  104.     procedure CallPurgeProc (blockToPurge: Handle;
  105.                                     userRoutine: PurgeUPP);
  106.     inline
  107.         $205F, $4E90;
  108.  
  109.     procedure CallUserFnProc (parameter: univ Ptr;
  110.                                     userRoutine: UserFnUPP);
  111.     {To be implemented:  Glue to move parameters into registers.}
  112.     function GetApplLimit: Ptr;
  113.     inline
  114.         $2EB8, $0130;            { MOVE.L $0130,(SP) }
  115.  
  116.     function SystemZone: THz;
  117.     inline
  118.         $2EB8, $02A6;            { MOVE.L $02A6,(SP) }
  119.  
  120.     function ApplicationZone: THz;
  121.     inline
  122.         $2EB8, $02AA;            { MOVE.L $02AA,(SP) }
  123.  
  124.     function GZSaveHnd: Handle;
  125.     inline
  126.         $2EB8, $0328;            { MOVE.L $0328,(SP) }
  127.  
  128.     function TopMem: Ptr;
  129.     inline
  130.         $2EB8, $0108;            { MOVE.L $0108,(SP) }
  131.  
  132.     function MemError: OSErr;
  133.     inline
  134.         $3EB8, $0220;            { MOVE.W $0220,(SP) }
  135.  
  136.     function GetZone: THz;
  137.     inline
  138.         $A11A, $2E88;
  139.     function NewHandle (byteCount: Size): Handle;
  140.     inline
  141.         $201F, $A122, $2E88;
  142.     function NewHandleSys (byteCount: Size): Handle;
  143.     inline
  144.         $201F, $A522, $2E88;
  145.     function NewHandleClear (byteCount: Size): Handle;
  146.     inline
  147.         $201F, $A322, $2E88;
  148.     function NewHandleSysClear (byteCount: Size): Handle;
  149.     inline
  150.         $201F, $A722, $2E88;
  151.     function HandleZone (h: Handle): THz;
  152.     inline
  153.         $205F, $A126, $2E88;
  154.     function RecoverHandle (p: Ptr): Handle;
  155.     inline
  156.         $205F, $A128, $2E88;
  157.     function RecoverHandleSys (p: Ptr): Handle;
  158.     inline
  159.         $205F, $A528, $2E88;
  160.     function NewPtr (byteCount: Size): Ptr;
  161.     inline
  162.         $201F, $A11E, $2E88;
  163.     function NewPtrSys (byteCount: Size): Ptr;
  164.     inline
  165.         $201F, $A51E, $2E88;
  166.     function NewPtrClear (byteCount: Size): Ptr;
  167.     inline
  168.         $201F, $A31E, $2E88;
  169.     function NewPtrSysClear (byteCount: Size): Ptr;
  170.     inline
  171.         $201F, $A71E, $2E88;
  172.     function PtrZone (p: Ptr): THz;
  173.     inline
  174.         $205F, $A148, $2E88;
  175.     function MaxBlock: LONGINT;
  176.     inline
  177.         $A061, $2E80;
  178.     function MaxBlockSys: LONGINT;
  179.     inline
  180.         $A461, $2E80;
  181.     function StackSpace: LONGINT;
  182.     inline
  183.         $A065, $2E80;
  184.     function NewEmptyHandle: Handle;
  185.     inline
  186.         $A166, $2E88;
  187.     function NewEmptyHandleSys: Handle;
  188.     inline
  189.         $A566, $2E88;
  190.     procedure HLock (h: Handle);
  191.     inline
  192.         $205F, $A029;
  193.     procedure HUnlock (h: Handle);
  194.     inline
  195.         $205F, $A02A;
  196.     procedure HPurge (h: Handle);
  197.     inline
  198.         $205F, $A049;
  199.     procedure HNoPurge (h: Handle);
  200.     inline
  201.         $205F, $A04A;
  202.     procedure HLockHi (h: Handle);
  203.     inline
  204.         $205F, $A064, $A029;
  205.     function TempNewHandle (logicalSize: Size;
  206.                                     var resultCode: OSErr): Handle;
  207.     inline
  208.         $3F3C, $001D, $A88F;
  209.     function TempMaxMem (var grow: Size): Size;
  210.     inline
  211.         $3F3C, $0015, $A88F;
  212.     function TempFreeMem: LONGINT;
  213.     inline
  214.         $3F3C, $0018, $A88F;
  215. {  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
  216.     procedure TempHLock (h: Handle;
  217.                                     var resultCode: OSErr);
  218.     inline
  219.         $3F3C, $001E, $A88F;
  220.     procedure TempHUnlock (h: Handle;
  221.                                     var resultCode: OSErr);
  222.     inline
  223.         $3F3C, $001F, $A88F;
  224.     procedure TempDisposeHandle (h: Handle;
  225.                                     var resultCode: OSErr);
  226.     inline
  227.         $3F3C, $0020, $A88F;
  228.     function TempTopMem: Ptr;
  229.     inline
  230.         $3F3C, $0016, $A88F;
  231.     procedure InitApplZone;
  232.     inline
  233.         $A02C;
  234.     procedure InitZone (pgrowZone: GrowZoneUPP;
  235.                                     cmoreMasters: INTEGER;
  236.                                     limitPtr: univ Ptr;
  237.                                     startPtr: univ Ptr);
  238.     procedure SetZone (hz: THz);
  239.     inline
  240.         $205F, $A01B;
  241.     function CompactMem (cbNeeded: Size): Size;
  242.     inline
  243.         $201F, $A04C, $2E80;
  244.     function CompactMemSys (cbNeeded: Size): Size;
  245.     inline
  246.         $201F, $A44C, $2E80;
  247.     procedure PurgeMem (cbNeeded: Size);
  248.     inline
  249.         $201F, $A04D;
  250.     procedure PurgeMemSys (cbNeeded: Size);
  251.     inline
  252.         $201F, $A44D;
  253.     function FreeMem: LONGINT;
  254.     inline
  255.         $A01C, $2E80;
  256.     function FreeMemSys: LONGINT;
  257.     inline
  258.         $A41C, $2E80;
  259.     procedure ReserveMem (cbNeeded: Size);
  260.     inline
  261.         $201F, $A040;
  262.     procedure ReserveMemSys (cbNeeded: Size);
  263.     inline
  264.         $201F, $A440;
  265.     function MaxMem (var grow: Size): Size;
  266.     inline
  267.         $225F, $A11D, $2288, $2E80;
  268.     function MaxMemSys (var grow: Size): Size;
  269.     inline
  270.         $225F, $A51D, $2288, $2E80;
  271.     procedure SetGrowZone (growZone: GrowZoneUPP);
  272.     inline
  273.         $205F, $A04B;
  274.     procedure SetApplLimit (zoneLimit: univ Ptr);
  275.     inline
  276.         $205F, $A02D;
  277.     procedure MoveHHi (h: Handle);
  278.     inline
  279.         $205F, $A064;
  280.     procedure DisposePtr (p: Ptr);
  281.     inline
  282.         $205F, $A01F;
  283.     function GetPtrSize (p: Ptr): Size;
  284.     procedure SetPtrSize (p: Ptr;
  285.                                     newSize: Size);
  286.     inline
  287.         $201F, $205F, $A020;
  288.     procedure DisposeHandle (h: Handle);
  289.     inline
  290.         $205F, $A023;
  291.     procedure SetHandleSize (h: Handle;
  292.                                     newSize: Size);
  293.     inline
  294.         $201F, $205F, $A024;
  295.     function GetHandleSize (h: Handle): Size;
  296. {$IFC TRUE}
  297.     inline
  298.         $205F,                                 { movea.l (sp)+, a0 }
  299.         $A025,                             { _GetHandleSize }
  300.         $2E80,                                 { move.l d0, (sp) }
  301.         $6A02,                             { bpl.s *+4 }
  302.         $4297;                                { clr.l (sp) }
  303. {$ENDC}
  304.     function InlineGetHandleSize (h: Handle): Size;
  305.     inline
  306.         $205F, $A025, $2E80;
  307.     procedure ReallocateHandle (h: Handle;
  308.                                     byteCount: Size);
  309.     inline
  310.         $201F, $205F, $A027;
  311.     procedure EmptyHandle (h: Handle);
  312.     inline
  313.         $205F, $A02B;
  314.     procedure HSetRBit (h: Handle);
  315.     inline
  316.         $205F, $A067;
  317.     procedure HClrRBit (h: Handle);
  318.     inline
  319.         $205F, $A068;
  320.     procedure MoreMasters;
  321.     inline
  322.         $A036;
  323.     procedure BlockMove (srcPtr: univ Ptr;
  324.                                     destPtr: univ Ptr;
  325.                                     byteCount: Size);
  326.     inline
  327.         $201F, $225F, $205F, $A02E;
  328.     procedure BlockMoveData (srcPtr: univ Ptr;
  329.                                     destPtr: univ Ptr;
  330.                                     byteCount: Size);
  331.     inline
  332.         $201F, $225F, $205F, $A22E;
  333.     procedure PurgeSpace (var total: LONGINT;
  334.                                     var contig: LONGINT);
  335.     function HGetState (h: Handle): SInt8;
  336.     inline
  337.         $205F, $A069, $1E80;
  338.     procedure HSetState (h: Handle;
  339.                                     flags: ByteParameter);
  340.     inline
  341.         $101F, $205F, $A06A;
  342.     procedure SetApplBase (startPtr: univ Ptr);
  343.     inline
  344.         $205F, $A057;
  345.     procedure MaxApplZone;
  346.     inline
  347.         $A063;
  348.     function HoldMemory (address: univ Ptr;
  349.                                     count: LONGINT): OSErr;
  350.     inline
  351.         $225F, $205F, $7000, $A05C, $3E80;
  352.     function UnholdMemory (address: univ Ptr;
  353.                                     count: LONGINT): OSErr;
  354.     inline
  355.         $225F, $205F, $7001, $A05C, $3E80;
  356.     function LockMemory (address: univ Ptr;
  357.                                     count: LONGINT): OSErr;
  358.     inline
  359.         $225F, $205F, $7002, $A05C, $3E80;
  360.     function LockMemoryContiguous (address: univ Ptr;
  361.                                     count: LONGINT): OSErr;
  362.     inline
  363.         $225F, $205F, $7004, $A05C, $3E80;
  364.     function UnlockMemory (address: univ Ptr;
  365.                                     count: LONGINT): OSErr;
  366.     inline
  367.         $225F, $205F, $7003, $A05C, $3E80;
  368.     function GetPhysical (var addresses: LogicalToPhysicalTable;
  369.                                     var physicalEntryCount: LONGINT): OSErr;
  370.     function DeferUserFn (userFunction: UserFnUPP;
  371.                                     argument: univ Ptr): OSErr;
  372.     inline
  373.         $201F, $205F, $A08F, $3E80;
  374.     function DebuggerGetMax: LONGINT;
  375.     inline
  376.         $7000, $A08D, $2E80;
  377.     procedure DebuggerEnter;
  378.     inline
  379.         $7001, $A08D;
  380.     procedure DebuggerExit;
  381.     inline
  382.         $7002, $A08D;
  383.     procedure DebuggerPoll;
  384.     inline
  385.         $7003, $A08D;
  386.     function GetPageState (address: univ Ptr): PageState;
  387.     inline
  388.         $205F, $7004, $A08D, $3E80;
  389.     function PageFaultFatal: BOOLEAN;
  390.     inline
  391.         $7005, $A08D, $1E80;
  392.     function DebuggerLockMemory (address: univ Ptr;
  393.                                     count: LONGINT): OSErr;
  394.     inline
  395.         $225F, $205F, $7006, $A08D, $3E80;
  396.     function DebuggerUnlockMemory (address: univ Ptr;
  397.                                     count: LONGINT): OSErr;
  398.     inline
  399.         $225F, $205F, $7007, $A08D, $3E80;
  400.     function EnterSupervisorMode: StatusRegisterContents;
  401.     inline
  402.         $7008, $A08D, $3E80;
  403.     function StripAddress (theAddress: univ Ptr): Ptr;
  404.     inline
  405.         $201F, $A055, $2E80;
  406.     function Translate24To32 (addr24: univ Ptr): Ptr;
  407.     inline
  408.         $201F, $A091, $2E80;
  409.     function HandToHand (var theHndl: Handle): OSErr;
  410.     function PtrToXHand (srcPtr: univ Ptr;
  411.                                     dstHndl: Handle;
  412.                                     size: LONGINT): OSErr;
  413.     inline
  414.         $201F, $225F, $205F, $A9E2, $3E80;
  415.     function PtrToHand (srcPtr: univ Ptr;
  416.                                     var dstHndl: Handle;
  417.                                     size: LONGINT): OSErr;
  418.     function HandAndHand (hand1: Handle;
  419.                                     hand2: Handle): OSErr;
  420.     inline
  421.         $225F, $205F, $A9E4, $3E80;
  422.     function PtrAndHand (ptr1: univ Ptr;
  423.                                     hand2: Handle;
  424.                                     size: LONGINT): OSErr;
  425.     inline
  426.         $201F, $225F, $205F, $A9EF, $3E80;
  427.  
  428. implementation
  429. end.